186 research outputs found
A Back-to-Basics Empirical Study of Priority Queues
The theory community has proposed several new heap variants in the recent
past which have remained largely untested experimentally. We take the field
back to the drawing board, with straightforward implementations of both classic
and novel structures using only standard, well-known optimizations. We study
the behavior of each structure on a variety of inputs, including artificial
workloads, workloads generated by running algorithms on real map data, and
workloads from a discrete event simulator used in recent systems networking
research. We provide observations about which characteristics are most
correlated to performance. For example, we find that the L1 cache miss rate
appears to be strongly correlated with wallclock time. We also provide
observations about how the input sequence affects the relative performance of
the different heap variants. For example, we show (both theoretically and in
practice) that certain random insertion-deletion sequences are degenerate and
can lead to misleading results. Overall, our findings suggest that while the
conventional wisdom holds in some cases, it is sorely mistaken in others
Hollow Heaps
We introduce the hollow heap, a very simple data structure with the same
amortized efficiency as the classical Fibonacci heap. All heap operations
except delete and delete-min take time, worst case as well as amortized;
delete and delete-min take amortized time on a heap of items.
Hollow heaps are by far the simplest structure to achieve this. Hollow heaps
combine two novel ideas: the use of lazy deletion and re-insertion to do
decrease-key operations, and the use of a dag (directed acyclic graph) instead
of a tree or set of trees to represent a heap. Lazy deletion produces hollow
nodes (nodes without items), giving the data structure its name.Comment: 27 pages, 7 figures, preliminary version appeared in ICALP 201
Optimal resizable arrays
A \emph{resizable array} is an array that can \emph{grow} and \emph{shrink}
by the addition or removal of items from its end, or both its ends, while still
supporting constant-time \emph{access} to each item stored in the array given
its \emph{index}. Since the size of an array, i.e., the number of items in it,
varies over time, space-efficient maintenance of a resizable array requires
dynamic memory management. A standard doubling technique allows the maintenance
of an array of size~ using only space, with amortized time, or
even worst-case time, per operation. Sitarski and Brodnik et al.\
describe much better solutions that maintain a resizable array of size~
using only space, still with time per operation. Brodnik
et al.\ give a simple proof that this is best possible.
We distinguish between the space needed for \emph{storing} a resizable array,
and accessing its items, and the \emph{temporary} space that may be needed
while growing or shrinking the array. For every integer , we show that
space is sufficient for storing and accessing an array of
size~, if space can be used briefly during grow and shrink
operations. Accessing an item by index takes worst-case time while grow
and shrink operations take amortized time. Using an exact analysis of a
\emph{growth game}, we show that for any data structure from a wide class of
data structures that uses only space to store the array, the
amortized cost of grow is , even if only grow and access operations
are allowed. The time for grow and shrink operations cannot be made worst-case,
unless .Comment: To appear in SOSA 202
Simple Concurrent Labeling Algorithms for Connected Components
We present new concurrent labeling algorithms for finding connected components, and we study their theoretical efficiency. Even though many such algorithms have been proposed and many experiments with them have been done, our algorithms are simpler. We obtain an O(lg n) step bound for two of our algorithms using a novel multi-round analysis. We conjecture that our other algorithms also take O(lg n) steps but are only able to prove an O(lg^2 n) bound. We also point out some gaps in previous analyses of similar algorithms. Our results show that even a basic problem like connected components still has secrets to reveal
- …